package main
import "fmt"
//func 函数名（形参列表）（返回值类型列表）{
//	执行语句...
//	return + 返回值列表
//}

//自定义函数：功能：两个数相加
/* func cal (num1 int,num2 int)(int){
	var sum int = 0
	sum = num1 + num2
	return sum 
}

func main(){
	sum := cal(10,20)
	fmt.Println(sum)
	var num1 int = 60
	var num2 int = 30
	sum2 := cal(num1,num2)
	fmt.Println(sum2)
} */

//返回值类型列表
//返回0个
/* func cal(num1 int,num2 int) { //没有返回值，就空着
	var sum int = 0
	sum = num1 + num2
	fmt.Println(sum)
}

func main(){
	cal(10,20)
} */

//返回1个
/* func cal(num1 int,num2 int) int { //返回值只有一个 可以不加()
	var sum int = 0
	sum = num1 + num2
	return sum
}
func main(){
	s := cal(1,6)
	fmt.Println(s)
} */

//返回多个
//计算两个数的和，两个数的差
/* func cal(num1 int,num2 int)(int,int){
	var sum int = 0
	sum = num1 + num2
	var result int = num1 - num2
	return sum,result
}
func main(){
	sum,result :=cal(60,20)
    fmt.Println(sum,result)
	sum1,_ := cal(66,22)
	fmt.Println(sum1)
} */

//交换两个数
//传值调用 - 无效
/* func exchangeNum (num1 int,num2 int) {
	var t int
	t = num1
	num1 = num2
	num2 = t
}
func main(){
	var n1 int = 20
	var n2 int = 36
	fmt.Printf("交换前n1:%v n2:%v\n",n1,n2)
	exchangeNum(n1,n2)
	fmt.Printf("交换前n1:%v n2:%v\n",n1,n2)
} */

//可变参数（需要带有可变数量的参数）
//定义一个函数，函数的参数为：可变参数... 参数的数量可以改变
//args...int可以传入任意多个数量的int类型数据，0/1/2..../n
/* func test (args...int){
	for i := 0;i<len(args);i++{
		//函数内部处理可变参数时，将可变参数当作切片来处理
		//编历可变参数
		fmt.Println(args[i])
	}
}
func main(){
	test()
	fmt.Println("-------------------")
	test(6)
	fmt.Println("-------------------")
	test(23,56,48,56)
} */

//基本数据类型和数组默认值传递，即进行值拷贝。在函数内修改，不会影响原来的值
/* func test (num int) {
	num = 30
	fmt.Println("test---",num)
}
func main(){
	var num int = 10
	test(num)
	fmt.Println("main---",num)
} */

//传地址调用
//如果希望用传值的方式，通过改变函数内的变量影响到函数外的变量，
//可以传入变量的地址&，通过指针的方式进行改变
/* func test (num *int) {
	*num = 30
}

func main(){
	var num int = 10
	fmt.Println(&num)
	test(&num)
	fmt.Println(num)
} */

//函数作为数据类型
/* func test (num int) {
	fmt.Println(num)
}
func main(){
	//函数作为数据类型赋值给变量
	a := test //变量就是一个函数类型的变量
	fmt.Printf("a的类型时：%T，test的函数类型是：%T\n",a,test)
	//通过该变量可以对函数调用
	a(10) //等价于test（10）
} */

//函数作为形参
//定义一个函数
/* func test(num int){
	fmt.Println(num)
}
//定义一个函数，把另一个函数作为形参：
func test02(num1 int,num2 float32, testFunc func(int)){
	fmt.Println("-----test02")
}
type myFunc func(int)
func test03 (num1 int,num2 float32,testFunc myFunc){
	fmt.Println("----")
}
func main(){
	a := test
	a(10)
	test02(10,3.18,test)
	test02(10,23.3,a)
} */

//自定义数据类型
//type自定义数据类型名 数据类型
//ep:type myInt int -->myInt 等价于int 使用
/* func main(){
	type myInt int
    var n1 myInt = 20
    fmt.Println(n1)
	var n2 int = 30
	//n2 = n1 //err myInt 与int 类型不匹配
	n2 = int(n1) //强制类型转换后可以使用
	fmt.Println(n2)
} */

/* func test04(num1 int,num2 int)(int,int){
	result01 := num1+num2
	result02 := num1-num2
	return result01,result02
} */
//对返回值命名
/* func test04(num1 int,num2 int)(m int,b int){
	b:= num1 - num2
	m:= num1 + num2
	return
}
func main(){
	a,b := test04(23,56)
	fmt.Println(a,b)
} */